package com.dts.yjnb.service.service.impl;

import java.util.*;
import java.util.stream.Collectors;
import org.springframework.util.StringUtils;

import com.dts.common.core.domain.model.LoginUser;
import com.dts.common.core.page.AppPageResult;
import com.dts.common.core.page.TableDataInfo;
import com.dts.common.exception.ServiceException;
import com.dts.common.utils.SecurityUtils;
import com.dts.system.service.ISysDictTypeService;
import com.dts.yjnb.service.domainDto.ProductDTO;
import com.dts.yjnb.service.domainVo.AppFarmProduceVo;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import com.dts.yjnb.service.domain.Product;
import com.dts.yjnb.service.mapper.ProductMapper;
import com.dts.yjnb.service.service.IProductService;

/**
 * 产品 服务层实现
 *
 * @author dts
 */
@Service
public class ProductServiceImpl implements IProductService
{
    private static final Logger log = LoggerFactory.getLogger(ProductServiceImpl.class);
    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private ISysDictTypeService dictTypeService;

    /**
     * 产品分页查询
     *
     * @param productDTO 查询条件
     * @return 分页结果
     */
    @Override
    public TableDataInfo pageQuery(ProductDTO productDTO)
    {
        //属性拷贝（包括beginTime和endTime）
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);

        // 开始分页
        PageHelper.startPage(productDTO.getPage(), productDTO.getPageSize());
        Page<Product> page = productMapper.pageQuery(product);

        long total = page.getTotal();
        List<Product> records = page.getResult();

        // 封装返回结果
        TableDataInfo tableDataInfo = new TableDataInfo();
        tableDataInfo.setTotal(total);
        tableDataInfo.setRows(records);

        return tableDataInfo;
    }

    /**
     * 根据ID查询产品详情
     *
     * @param id 产品ID
     * @return 产品详情
     */
    @Override
    public Product getByid(Long id) {
        // 参数校验
        if (id == null) {
            throw new ServiceException("产品ID不能为空");
        }

        // 查询产品详情
        Product product = productMapper.getByid(id);

        // 校验查询结果
        if (product == null) {
            throw new ServiceException("产品不存在");
        }

        return product;
    }

    /**
     * 农产品批量删除
     * @param ids
     */
    @Override
    public void deleteByids(List<Long> ids) {
        //先判断ids是否存在值,不存在则没必要访问数据库
        if (ids == null || ids.size() == 0) {
            throw new ServiceException("请选择要删除的产品");
        } else {
            //删除农产品
            Integer count = productMapper.deleteByids(ids);
            if (count == 0) {
                throw new ServiceException("删除失败，产品不存在");
            }
        }
    }

    /**
     * 批量修改产品状态
     *
     * @param ids 产品ID列表
     * @param status 状态：1上架 0下架
     */
    @Override
    public void updateStatusByids(List<Long> ids, Integer status) {
        //先判断ids是否存在值,不存在则没必要访问数据库
        if (ids == null || ids.size() == 0) {
            throw new ServiceException("请选择要操作的产品");
        }
        //校验状态参数
        if (status == null || (status != 0 && status != 1)) {
            throw new ServiceException("状态参数错误");
        }

        //批量修改状态
        Integer count = productMapper.updateStatusByids(ids, status);
        if (count == 0) {
            throw new ServiceException("修改失败，产品不存在");
        }
    }

    /**
     * 批量修改产品推荐状态
     *
     * @param ids 产品ID列表
     * @param isRecommend 推荐状态：1推荐 0不推荐
     */
    @Override
    public void updateRecommendByids(List<Long> ids, Integer isRecommend) {
        //先判断ids是否存在值,不存在则没必要访问数据库
        if (ids == null || ids.size() == 0) {
            throw new ServiceException("请选择要操作的产品");
        }
        //校验推荐状态参数
        if (isRecommend == null || (isRecommend != 0 && isRecommend != 1)) {
            throw new ServiceException("推荐状态参数错误");
        }

        //批量修改推荐状态
        Integer count = productMapper.updateRecommendByids(ids, isRecommend);
        if (count == 0) {
            throw new ServiceException("修改失败，产品不存在");
        }
    }

    /**
     * 产品新增
     *
     * @param productDTO 产品信息
     */
    @Override
    public void add(ProductDTO productDTO) {
        // 参数校验
        if (productDTO == null) {
            throw new ServiceException("产品信息不能为空");
        }
        if (productDTO.getName() == null || productDTO.getName().isEmpty()) {
            throw new ServiceException("产品名称不能为空");
        }
        if (productDTO.getCategoryId() == null) {
            throw new ServiceException("产品分类不能为空");
        }
        if (productDTO.getPrice() == null) {
            throw new ServiceException("产品价格不能为空");
        }
        //获取当前用户信息
        LoginUser loginUser = SecurityUtils.getLoginUser();
        // DTO转换为实体类
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);

        //当前用户修改
        product.setUpdateBy(loginUser.getUsername());
        log.info("当前用户{}",loginUser.getUsername());
        // 执行新增
        Integer count = productMapper.add(product);

        // 校验新增结果
        if (count == 0) {
            throw new ServiceException("新增失败");
        }
    }

    /**
     * 产品编辑
     *
     * @param productDTO 产品信息
     */
    @Override
    public void update(ProductDTO productDTO) {
        // 参数校验
        if (productDTO == null || productDTO.getId() == null) {
            throw new ServiceException("产品ID不能为空");
        }
        //获取当前用户信息
        LoginUser loginUser = SecurityUtils.getLoginUser();

        // DTO转换为实体类
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);
        product.setUpdateBy(loginUser.getUsername());
        product.setUpdateTime(new Date());

        // 执行更新
        Integer count = productMapper.update(product);

        // 校验更新结果
        if (count == 0) {
            throw new ServiceException("修改失败，产品不存在");
        }
    }

    /**
     * APP产品分页查询
     *
     * @param page 页码
     * @param pageSize 每页数量
     * @param produceType 产品类型编码（字典值），0表示全部
     * @return 分页结果（包含list, pageNum, navigateLastPage）
     */
    @Override
    public Map<String, Object> pageAppFarmProduce(Integer page, Integer pageSize, Integer produceType) {
        if (page == null || page < 1) {
            page = 1;
        }
        if (pageSize == null || pageSize < 1) {
            pageSize = 10;
        }

        // 构建查询条件
        Product product = new Product();
        product.setStatus(1); // 只查询已上架的产品

        // 如果produceType不为0，尝试根据字典值查找对应的categoryId
        // 注意：这里假设produceType（字典值）与categoryId有某种对应关系
        // 实际情况可能需要根据业务需求调整
        if (produceType != null && produceType != 0) {
            // 可以通过字典值查找对应的分类，这里简化处理
            // 实际可能需要根据字典值的映射关系来确定categoryId
            // 暂时先不设置categoryId，后续可根据实际业务调整
            // product.setCategoryId(...);
        }

        // 开始分页
        PageHelper.startPage(page, pageSize);
        Page<Product> pagedomain = productMapper.pageQuery(product);

        long total = pagedomain.getTotal();
        List<Product> records = pagedomain.getResult();

        // 转换为APP需要的格式
        List<AppFarmProduceVo> voList = records.stream().map(p -> {
            AppFarmProduceVo vo = new AppFarmProduceVo();
            vo.setId(String.valueOf(p.getId()));

            // 处理图片：取第一张图片
            if (!StringUtils.isEmpty(p.getImages())) {
                String[] images = p.getImages().split(",");
                vo.setImage(images.length > 0 ? images[0].trim() : "");
            } else {
                vo.setImage("");
            }

            vo.setTitle(p.getName());
            vo.setResume(p.getCategoryName() != null ? p.getCategoryName() : ""); // 使用分类名称作为简介
            vo.setPrice(p.getPrice() != null ? p.getPrice().doubleValue() : 0.0);
            vo.setBrowseNum(p.getViewNum() != null ? p.getViewNum() : 0);
            vo.setProviderName(p.getMerchantName() != null ? p.getMerchantName() : "");
            return vo;
        }).collect(Collectors.toList());

        // 计算总页数
        int totalPages = (int) Math.ceil((double) total / pageSize);

        // 封装返回结果
        Map<String, Object> result = new HashMap<>();
        result.put("list", voList);
        result.put("page", page);
        result.put("navigateLastPage", totalPages);

        return result;
    }

    @Override
    public AppPageResult pageAppFarmProduce1(ProductDTO productDTO) {

        //属性拷贝（包括beginTime和endTime）
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);

        // 开始分页
        PageHelper.startPage(productDTO.getPage(), productDTO.getPageSize());
        Page<Product> page = productMapper.pageQuery(product);

        long total = page.getTotal();
        List<Product> records = page.getResult();

        //拿图片的第一张图片
        for (Product record : records) {
            String images = record.getImages(); // 假设原始图片字符串格式为 "img1,img2,img3"
            if (images != null && !images.isEmpty()) {
                String[] imageArr = images.split(","); // 按逗号分割
                if (imageArr.length > 0) {
                    record.setImages(imageArr[0]); // 只保留第一张图片
                }
            }
        }

        // 封装返回结果
        AppPageResult appPageResult = new AppPageResult();
        appPageResult.setTotal(total);
        appPageResult.setRows(records);
        appPageResult.setPage(productDTO.getPage());
        appPageResult.setSuccess(true);

        return appPageResult;
    }

    /**
     * APP端精品推荐列表查询（推荐且上架的产品）
     *
     * @param productDTO 查询参数
     * @return 产品列表
     */
    @Override
    public AppPageResult getRecommendProductList(ProductDTO productDTO) {
        log.info("APP端精品推荐列表查询，参数：{}", productDTO);

        // 设置查询条件：只查询推荐且上架的产品
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);
        product.setIsRecommend(1); // 推荐
        product.setStatus(1); // 上架

        // 开始分页
        PageHelper.startPage(productDTO.getPage(), productDTO.getPageSize());
        Page<Product> page = productMapper.pageQuery(product);

        long total = page.getTotal();
        List<Product> records = page.getResult();

        // 转换数据格式为前端需要的格式
        List<Map<String, Object>> resultList = records.stream().map(p -> {
            Map<String, Object> item = new HashMap<>();
            item.put("id", p.getId());

            // 处理图片：取第一张图片
            if (!StringUtils.isEmpty(p.getImages())) {
                String[] images = p.getImages().split(",");
                item.put("image", images.length > 0 ? images[0].trim() : "");
            } else {
                item.put("image", "");
            }

            item.put("title", p.getName() != null ? p.getName() : "");
            item.put("price", p.getPrice() != null ? p.getPrice().doubleValue() : 0.0);
            item.put("browseNum", p.getViewNum() != null ? p.getViewNum() : 0);

            // produceType: 根据categoryId映射
            Long categoryId = p.getCategoryId();
            if (categoryId != null) {
                if (categoryId == 2) { // 时令水果
                    item.put("produceType", 1);
                } else if (categoryId == 1) { // 新鲜蔬菜
                    item.put("produceType", 2);
                } else {
                    item.put("produceType", 0);
                }
            } else {
                item.put("produceType", 0);
            }

            return item;
        }).collect(Collectors.toList());

        // 封装返回结果
        AppPageResult appPageResult = new AppPageResult();
        appPageResult.setTotal(total);
        appPageResult.setRows(resultList);
        appPageResult.setPage(productDTO.getPage());
        appPageResult.setSuccess(true);

        return appPageResult;
    }
}
